namespace launch {
//namespace cframework
//{
//    using System.Collections.Generic;
//    using UnityEngine;
//    using System.IO;
//    using System.Reflection;

//    /// <summary>
//    /// 支持字段的CSV序列化/反序列化示例（包含公共字段、私有字段、混合属性+字段场景）
//    /// </summary>
//    public class CsvFieldUsageExample : MonoBehaviour
//    {
//        // CSV文件保存路径（Unity可读写路径）
//        private string _weaponCsvPath;
//        private string _playerCsvPath;
//        private string _mixedCsvPath;

//        private void Awake()
//        {
//            // 初始化文件路径（PersistentDataPath支持读写，跨平台）
//            _weaponCsvPath = Path.Combine(Application.persistentDataPath, "WeaponData.csv");
//            _playerCsvPath = Path.Combine(Application.persistentDataPath, "PlayerFieldData.csv");
//            _mixedCsvPath = Path.Combine(Application.persistentDataPath, "MixedPropFieldData.csv");
//        }

//        private void Start()
//        {
//            Debug.Log("=== 开始测试字段CSV序列化 ===");

//            // 示例1：纯字段序列化（武器数据，含公共字段+自定义表头）
//            TestWeaponFieldSerialization();

//            // 示例2：含私有字段的序列化（需指定BindingFlags）
//            TestPlayerPrivateFieldSerialization();

//            // 示例3：混合属性+字段的序列化
//            TestMixedPropFieldSerialization();
//        }

//        #region 示例1：纯字段序列化（武器数据）
//        /// <summary>
//        /// 武器数据类（纯字段，使用CsvColumn特性自定义表头）
//        /// </summary>
//        public class WeaponData
//        {
//            [CsvColumn("武器ID")] // 自定义表头名
//            public int WeaponId;

//            [CsvColumn("武器名称")]
//            public string WeaponName;

//            [CsvColumn("攻击伤害")]
//            public float AttackDamage;

//            [CsvColumn("是否可升级")]
//            public bool CanUpgrade;

//            [CsvColumn(Ignore = true)] // 忽略该字段（不写入CSV）
//            public string InternalRemark; // 内部备注，不需要序列化
//        }

//        /// <summary>
//        /// 测试纯字段的序列化与反序列化
//        /// </summary>
//        private void TestWeaponFieldSerialization()
//        {
//            Debug.Log("\n--- 测试1：纯字段序列化（武器数据） ---");

//            // 1. 构造测试数据（含忽略字段赋值）
//            var weaponList = new List<WeaponData>
//        {
//            new WeaponData
//            {
//                WeaponId = 1001,
//                WeaponName = "钢铁长剑",
//                AttackDamage = 125.5f,
//                CanUpgrade = true,
//                InternalRemark = "新手武器，基础属性" // 该字段会被忽略
//            },
//            new WeaponData
//            {
//                WeaponId = 1002,
//                WeaponName = "火焰法杖",
//                AttackDamage = 98.0f,
//                CanUpgrade = false,
//                InternalRemark = "魔法武器，带火焰伤害"
//            }
//        };

//            // 2. 序列化（纯字段，包含表头）
//            string csvText = CsvSerializer.SerializeToCsv(weaponList, includeHeader: true);
//            // 保存到文件
//            CsvSerializer.SaveCsvToFile(csvText, _weaponCsvPath);

//            // 3. 反序列化（从文件读取）
//            string loadedCsv = CsvSerializer.LoadCsvFromFile(_weaponCsvPath);
//            List<WeaponData> deserializedWeapons = CsvSerializer.DeserializeFromCsv<WeaponData>(loadedCsv, hasHeader: true);

//            // 4. 打印结果（验证忽略字段是否未被反序列化）
//            Debug.Log("反序列化武器数据结果：");
//            foreach (var weapon in deserializedWeapons)
//            {
//                Debug.Log($"ID：{weapon.WeaponId} | 名称：{weapon.WeaponName} | 伤害：{weapon.AttackDamage} | 可升级：{weapon.CanUpgrade} | 忽略字段：{weapon.InternalRemark ?? "null"}");
//            }
//        }
//        #endregion

//        #region 示例2：含私有字段的序列化（玩家数据）
//        /// <summary>
//        /// 玩家数据类（含私有字段，需通过BindingFlags访问）
//        /// </summary>
//        public class PlayerFieldData
//        {
//            // 公共字段
//            [CsvColumn("玩家ID")]
//            public string PlayerId;

//            [CsvColumn("昵称")]
//            public string Nickname;

//            // 私有字段（需在序列化时指定BindingFlags包含NonPublic）
//            [CsvColumn("当前等级")]
//            private int _level;

//            [CsvColumn("剩余血量")]
//            private float _remainingHp;

//            [CsvColumn("是否在线")]
//            private bool _isOnline;

//            // 构造函数（初始化私有字段）
//            public PlayerFieldData() { }

//            public PlayerFieldData(string playerId, string nickname, int level, float remainingHp, bool isOnline)
//            {
//                PlayerId = playerId;
//                Nickname = nickname;
//                _level = level;
//                _remainingHp = remainingHp;
//                _isOnline = isOnline;
//            }

//            // 辅助方法：打印私有字段（验证反序列化结果）
//            public void PrintPrivateFields()
//            {
//                Debug.Log($"等级：{_level} | 血量：{_remainingHp} | 在线状态：{_isOnline}");
//            }
//        }

//        /// <summary>
//        /// 测试含私有字段的序列化（需指定BindingFlags = Public | NonPublic | Instance）
//        /// </summary>
//        private void TestPlayerPrivateFieldSerialization()
//        {
//            Debug.Log("\n--- 测试2：含私有字段的序列化（玩家数据） ---");

//            // 1. 构造测试数据（包含私有字段）
//            var playerList = new List<PlayerFieldData>
//        {
//            new PlayerFieldData("P001", "战神阿凯", 50, 2500.7f, true),
//            new PlayerFieldData("P002", "法师莉莉", 45, 1800.3f, false)
//        };

//            // 2. 序列化（需指定BindingFlags包含NonPublic，才能访问私有字段）
//            var bindingFlags = BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Instance;
//            string csvText = CsvSerializer.SerializeToCsv(playerList, includeHeader: true, bindingFlags: bindingFlags);
//            CsvSerializer.SaveCsvToFile(csvText, _playerCsvPath);

//            // 3. 反序列化（同样需要指定BindingFlags，才能给私有字段赋值）
//            string loadedCsv = CsvSerializer.LoadCsvFromFile(_playerCsvPath);
//            List<PlayerFieldData> deserializedPlayers = CsvSerializer.DeserializeFromCsv<PlayerFieldData>(
//                loadedCsv, hasHeader: true, bindingFlags: bindingFlags);

//            // 4. 打印结果（通过辅助方法验证私有字段是否正确赋值）
//            Debug.Log("反序列化玩家数据结果：");
//            foreach (var player in deserializedPlayers)
//            {
//                Debug.Log($"玩家ID：{player.PlayerId} | 昵称：{player.Nickname} | 私有字段：");
//                player.PrintPrivateFields();
//            }
//        }
//        #endregion

//        #region 示例3：混合属性+字段的序列化
//        /// <summary>
//        /// 混合数据类（同时包含属性和字段）
//        /// </summary>
//        public class MixedPropFieldData
//        {
//            // 字段
//            [CsvColumn("物品ID")]
//            public int ItemId;

//            [CsvColumn("物品类型")]
//            public string ItemType;

//            // 属性（带get/set）
//            [CsvColumn("物品名称")]
//            public string ItemName { get; set; }

//            [CsvColumn("物品价格")]
//            public int ItemPrice { get; set; }

//            // 只读属性（无set，会被忽略，因为无法赋值）
//            public string ItemDescription { get; } = "默认描述";

//            // 字段（带CsvColumn忽略）
//            [CsvColumn(Ignore = true)]
//            public string TempData; // 临时数据，不序列化
//        }

//        /// <summary>
//        /// 测试混合属性+字段的序列化
//        /// </summary>
//        private void TestMixedPropFieldSerialization()
//        {
//            Debug.Log("\n--- 测试3：混合属性+字段的序列化 ---");

//            // 1. 构造测试数据
//            var mixedList = new List<MixedPropFieldData>
//        {
//            new MixedPropFieldData
//            {
//                ItemId = 2001,
//                ItemType = "消耗品",
//                ItemName = "高级生命药水",
//                ItemPrice = 500,
//                TempData = "临时标记：已上架" // 该字段会被忽略
//            },
//            new MixedPropFieldData
//            {
//                ItemId = 2002,
//                ItemType = "装备",
//                ItemName = "青铜铠甲",
//                ItemPrice = 1200,
//                TempData = "临时标记：库存不足"
//            }
//        };

//            // 2. 序列化（自动识别属性和字段）
//            string csvText = CsvSerializer.SerializeToCsv(mixedList, includeHeader: true);
//            CsvSerializer.SaveCsvToFile(csvText, _mixedCsvPath);

//            // 3. 反序列化（只读属性无set，会被赋值为默认值）
//            string loadedCsv = CsvSerializer.LoadCsvFromFile(_mixedCsvPath);
//            List<MixedPropFieldData> deserializedMixed = CsvSerializer.DeserializeFromCsv<MixedPropFieldData>(loadedCsv, hasHeader: true);

//            // 4. 打印结果（验证属性和字段是否正确赋值，忽略字段是否为空）
//            Debug.Log("反序列化混合属性+字段结果：");
//            foreach (var data in deserializedMixed)
//            {
//                Debug.Log($"ID：{data.ItemId} | 类型：{data.ItemType} | 名称：{data.ItemName} | 价格：{data.ItemPrice} | 只读描述：{data.ItemDescription} | 忽略字段：{data.TempData ?? "null"}");
//            }
//        }
//        #endregion
//    }
//}
}